﻿#include<iostream>
#include<vector>
#include<list>
#include<deque>
using namespace std;
//class Student
//{
//public:
//	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
//	void identity()
//	{
//		// ...
//	}
//	// 学习
//	void study()
//	{
//		// ...
//	}
//protected:
//	string _name = "peter"; // 姓名
//	string _address; // 地址
//	string _tel; // 电话
//	int _age = 18; // 年龄
//	int _stuid; // 学号
//};
//class Teacher
//{
//public:
//		// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
//		void identity()
//	{
//		// ...
//	}
//	// 授课
//	void teaching()
//	{
//		//...
//	}
//protected:
//	string _name = "张三"; // 姓名
//	int _age = 18; // 年龄
//	string _address; // 地址
//	string _tel; // 电话
//	string _title; // 职称
//};
//
//
//int main()
//{
//	return 0;
//}

//class Person
//{
//public:
//	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
//	void identity()
//	{
//		cout << "void identity()" << _name << endl;
//	}
//protected:
//	string _name = "张三"; // 姓名
//	string _address; // 地址
//	string _tel; // 电话
//	int _age = 18; // 年龄
//};
//class Student : public Person
//{
//public:
//	// 学习
//	void study()
//	{
//		// ...
//	}
//protected:
//	int _stuid; // 学号
//};
//class Teacher : public Person
//{
//public:
//	// 授课
//	void teaching()
//	{
//		//...
//	}
//protected:
//	string title; // 职称
//};
//int main()
//{
//	Student s;
//	Teacher t;
//	s.identity();
//	t.identity();
//	return 0;
//}

//#define CONTAINER std::vector
//#define CONTAINER std::list
//#define CONTAINER std::deque
//
//namespace sy
//{
//	//template<class T>
//	//class vector
//	//{};
//	// stack和vector的关系，既符合is-a，也符合has-a
//	template<class T>
//	class stack : public CONTAINER<T>
//	{
//	public:
//		void push(const T& x)
//		{
//			// 基类是类模板时，需要指定⼀下类域，
//            // 否则编译报错:error C3861: “push_back”: 找不到标识符
//			// 因为stack<int>实例化时，也实例化vector<int>了
//			// 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到
//			CONTAINER<T>::push_back(x);
//			//push_back(x);
//		}
//
//		void pop()
//		{
//			CONTAINER<T>::pop_back();
//		}
//
//		const T& top()
//		{
//			return CONTAINER<T>::back();
//		}
//
//		bool empty()
//		{
//			return CONTAINER<T>::empty();
//		}
//	};
//
//
//	template<class T>
//	class A
//	{
//	public:
//		A()
//		{
//			//func();
//		}
//
//		void push(const T& x)
//		{
//			x.func();
//		}
//	};
//}

//int main()
//{
//	sy::stack<int> st;
//	st.push(1);
//	st.push(2);
//	st.push(3);
//	while (!st.empty())
//	{
//		cout << st.top() << " ";
//		st.pop();
//	}
//
//	sy::A<int> aa;
//	//aa.push(1);
//
//	return 0;
//}

//class Person
//{
//	//多态
//	virtual void func()
//	{}
//public:
//	string _name; // 姓名
//	string _sex; // 性别
//	int _age; // 年龄
//};
//
//class Student : public Person
//{
//public:
//	int _No; // 学号
//};
//
//int main()
//{
//	Student sobj;
//
//	// 1.子类对象可以赋值给父类对象/指针/引用
//	Person pobj = sobj;
//	Person* pp = &sobj;
//	Person& rp = sobj;
//	rp._name = "张三";
//
//	int i = 1;
//	double d = i;
//	const double& rd = i;
//
//	//2.父类对象不能赋值给子类对象，这里会编译报错
//	//sobj = (Student)pobj;
//
//	// 后面再细讲，这里简单了解一下
//	Student* ps1 = dynamic_cast<Student*>(pp);
//	cout << ps1 << endl;
//
//	pp = &pobj;
//	Student* ps2 = dynamic_cast<Student*>(pp);
//	cout << ps2 << endl;
//
//	return 0;
//}

////Student的_num和Person的_num构成隐藏关系，
////可以看出这样代码虽然能跑，但是⾮常容易混淆
//class Person
//{
//protected:
//	string _name = "张三"; // 姓名
//	int _num = 1111212121; // 身份证号
//};
//
//class Student : public Person
//{
//public:
//	void Print()
//	{
//		cout << _num << endl;
//		cout << Person::_num << endl;
//	}
//protected:
//	int _num = 999; // 学号
//};
//
//int main()
//{
//
//	Student s;
//	s.Print();
//	return 0;
//}
////运行结果：
////999
////1111212121


//class A
//{
//public:
//	void fun()
//	{
//		cout << "func()" << endl;
//	}
//};
//
//class B : public A
//{
//public:
//	void fun(int i)
//	{
//		cout << "func(int i)" << i << endl;
//	}
//};
//
//int main()
//{
//	B b;
//	b.A::fun();
//	b.fun(1);
//
//
//	return 0;
//};

//class Person
//{
//public:
//	Person(const char* name = "xxx")
//		: _name(name)
//	{
//		cout << "Person()" << endl;
//	}
//
//	Person(const Person& p)
//		: _name(p._name)
//	{
//		cout << "Person(const Person& p)" << endl;
//	}
//
//	Person& operator=(const Person& p)
//	{
//		cout << "Person operator=(const Person& p)" << endl;
//		if (this != &p)
//			_name = p._name;
//		return *this;
//	}
//
//	~Person()
//	{
//		cout << "~Person()" << endl;
//	}
//protected:
//	string _name; // 姓名
//};
//
//class Student : public Person
//{
//public:
//	Student(const char* name, int num, const char* addrss)
//		:Person(name)
//		, _num(num)
//		, _addrss(addrss)
//	{}
//
//	// 严格说Student拷贝构造默认生成的就够用了
//	// 如果有需要深拷贝的资源，才需要自己实现
//	Student(const Student& s)
//		:Person(s)
//		, _num(s._num)
//		, _addrss(s._addrss)
//	{
//		// 深拷贝
//	}
//
//	// 严格说Student赋值重载默认生成的就够用了
//	// 如果有需要深拷贝的资源，才需要自己实现
//	Student& operator=(const Student& s)
//	{
//		if (this != &s)
//		{
//			// 父类和子类的operator=构成隐藏关系
//			Person::operator=(s);
//			_num = s._num;
//			_addrss = s._addrss;
//		}
//
//		return *this;
//	}
//
//	// 严格说Student析构默认生成的就够用了
//	// 如果有需要显示释放的资源，才需要自己实现
//	// 析构函数都会被特殊处理成destructor() 
//	~Student()
//	{
//		// 子类的析构和父类析构函数也构成隐藏关系
//		// 规定：不需要显示调用，子类析构函数之后，会自动调用父类析构
//		// 这样保证析构顺序，先子后父，显示调用取决于实现的人，不能保证
//		// 先子后父
//		/*Person::~Person();
//		delete _ptr;*/
//	}
//protected:
//	int _num = 1; //学号
//	string _addrss = "阳光大道";
//
//	int* _ptr = new int[10];
//};
//
//int main()
//{
//	Student s1("张三", 1, "北京市");
//	Student s2(s1);
//
//	Student s3("李四", 2, "南京市");
//	s1 = s3;
//
//	//Person* ptr = new Person;
//	//delete ptr;
//
//	return 0;
//}
//运行结果
//Person()
//Person(const Person& p)
//Person()
//Person operator=(const Person& p)
//~Person()
//~Person()
//~Person()


//// C++11的⽅法
//class Base final
//{
//public:
//	void func5() { cout << "Base::func5" << endl; }
//protected:
//	int a = 1;
//private:
//	// C++98的⽅法
//	/*Base()
//	{}*/
//};
//
//class Derive :public Base
//{
//	void func4() { cout << "Derive::func4" << endl; }
//protected:
//	int b = 2;
//};
//int main()
//{
//	Base b;
//	Derive d;
//	return 0;
//}

////前置声明
//class Student;
//class Person
//{
//public:
//	friend void Display(const Person& p, const Student& s);
//protected:
//	string _name; // 姓名
//};
//class Student : public Person
//{
//	//friend void Display(const Person& p, const Student& s);
//protected:
//	int _stuNum; // 学号
//};
//void Display(const Person& p, const Student& s)
//{
//	cout << p._name << endl;
//	cout << s._stuNum << endl;
//}
//int main()
//{
//	Person p;
//	Student s;
//	// 编译报错：error C2248: “Student::_stuNum”: ⽆法访问 protected 成员
//	// 解决⽅案：Display也变成Student 的友元即可
//	Display(p, s);
//	return 0;
//}

//class Person
//{
//public:
//	string _name;
//	static int _count;
//};
////类外初始化
//int Person::_count = 0;
//class Student : public Person
//{
//protected:
//	int _stuNum;
//};
//int main()
//{
//	Person p;
//	Student s;
//	// 这⾥的运⾏结果可以看到⾮静态成员_name的地址是不⼀样的
//	// 说明子类继承下来了，⽗、子类对象各有⼀份
//	cout << &p._name << endl;
//	cout << &s._name << endl;
//	// 这⾥的运⾏结果可以看到静态成员_count的地址是⼀样的
//	// 说明子类和父类共⽤同⼀份静态成员
//	cout << &p._count << endl;
//	cout << &s._count << endl;
//	// 公有的情况下，父、子⽣类指定类域都可以访问静态成员
//	cout << Person::_count << endl;
//	cout << Student::_count << endl;
//	return 0;
//}

//
//class Person
//{
//public:
//	string _name; // 姓名
//};
//class Student : public Person
//{
//protected:
//	int _num; //学号
//};
//class Teacher : public Person
//{
//protected:
//	int _id; // 职⼯编号
//};
//class Assistant : public Student, public Teacher
//{
//protected:
//	string _majorCourse; // 主修课程
//};
//int main()
//{
//	// 编译报错：error C2385: 对“_name”的访问不明确
//	Assistant a;
//	//a._name = "peter";
//	// 需要显⽰指定访问哪个基类的成员可以解决⼆义性问题，但是数据冗余问题⽆法解决
//	a.Student::_name = "xxx";
//	a.Teacher::_name = "yyy";
//	return 0;
//}

//class Person
//{
//public:
//	string _name; // 姓名
//	/*int _tel;
//	int _age;
//	string _gender;
//	string _address;*/
//	// ...
//};
//// 使⽤虚继承Person类
//class Student : virtual public Person
//{
//protected:
//	int _num; //学号
//};
//// 使⽤虚继承Person类
//class Teacher : virtual public Person
//{
//protected:
//	int _id; // 职⼯编号
//};
//// 教授助理
//class Assistant : public Student, public Teacher
//{
//protected:
//	string _majorCourse; // 主修课程
//};
//int main()
//{
//	// 使⽤虚继承，可以解决数据冗余和⼆义性
//	Assistant a;
//	a._name = "peter";
//	return 0;
//}

// Tire(轮胎)和Car(⻋)更符合has-a的关系
class Tire {
protected:
	string _brand = "Michelin"; // 品牌
	size_t _size = 17; // 尺⼨
};
class Car {
protected:
	string _colour = "⽩⾊"; // 颜⾊
	string _num = "陕ABIT00"; // ⻋牌号
	Tire _t1; // 轮胎
	Tire _t2; // 轮胎
	Tire _t3; // 轮胎
	Tire _t4; // 轮胎
};

class BMW : public Car 
{
public:
	void Drive() { cout << "好开-操控" << endl; }
};
// Car和BMW/Benz更符合is-a的关系
class Benz : public Car 
{
public:
	void Drive() { cout << "好坐-舒适" << endl; }
};
template<class T>
class vector
{};
// stack和vector的关系，既符合is-a，也符合has-a
template<class T>
class stack : public vector<T>
{};
template<class T>
class stack
{
public:
	vector<T> _v;
};
int main()
{
	return 0;
}